package service

import (
	"context"
	"fmt"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"time"
)

// ChatRoom 聊天室结构体
type ChatRoom struct {
	ID             primitive.ObjectID `bson:"_id,omitempty"`
	Members        []string           `bson:"members"`
	UnreadMessages map[string]int     `bson:"unreadMessages"` // 用户的未读消息数量，键为用户ID，值为未读消息数量
	LastActiveTime int64              `bson:"lastActiveTime"`
	LastMessage    string             `bson:"lastMessage"` // 最近一条消息
}

// ChatMessage 聊天消息结构体
type ChatMessage struct {
	ID        primitive.ObjectID `bson:"_id,omitempty"`
	RoomID    primitive.ObjectID `bson:"roomID"`
	SenderID  string             `bson:"senderID"`
	Content   string             `bson:"content"`
	Read      bool               `bson:"read"`
	Timestamp int64              `bson:"timestamp"`
}

// 检查是否存在聊天室，如果不存在则创建聊天室
func ensureChatRoomExists(collection *mongo.Collection, user1ID, user2ID string) (*ChatRoom, error) {
	// 构建查询条件
	filter := bson.M{
		"members": bson.M{
			"$all": []string{user1ID, user2ID},
		},
	}

	// 执行查询
	var chatRoom ChatRoom
	err := collection.FindOne(context.Background(), filter).Decode(&chatRoom)
	if err == nil {
		// 聊天室已存在，无需创建
		fmt.Println("聊天室已存在")
		return &chatRoom, nil
	}

	if err != mongo.ErrNoDocuments {
		// 查询出错
		return nil, fmt.Errorf("查询聊天室时出错: %v", err)
	}

	// 聊天室不存在，创建聊天室
	chatRoom = ChatRoom{
		Members: []string{user1ID, user2ID},
		UnreadMessages: map[string]int{
			user1ID: 0, // 初始化用户1的未读消息数量为0
			user2ID: 0, // 初始化用户2的未读消息数量为0
		},
		LastMessage:    "",
		LastActiveTime: time.Now().Unix(),
	}
	//fmt.Println("111111111111")
	//fmt.Println("我要存储时间：", chatRoom.LastActiveTime)

	result, err := collection.InsertOne(context.Background(), chatRoom)
	if err != nil {
		return nil, fmt.Errorf("插入聊天室时出错: %v", err)
	}

	// 获取插入文档的ID
	insertedID := result.InsertedID
	// 将插入文档的ID转换为字符串类型，并赋值给chatRoom
	chatRoomID, ok := insertedID.(primitive.ObjectID)
	if !ok {
		return nil, fmt.Errorf("无法转换插入文档的ID为ObjectID类型")
	}
	chatRoom.ID = chatRoomID
	fmt.Println("创建聊天室成功")
	return &chatRoom, nil
}

// 根据userID查询所有的聊天室
func findChatRoomsByUserID(collection *mongo.Collection, userID string) ([]ChatRoom, error) {
	// 构建查询条件
	filter := bson.M{
		"members": userID,
	}

	// 执行查询
	cursor, err := collection.Find(context.Background(), filter)
	if err != nil {
		return nil, fmt.Errorf("查询聊天室时出错: %v", err)
	}
	defer cursor.Close(context.Background())

	// 解码查询结果
	var chatRooms []ChatRoom
	for cursor.Next(context.Background()) {
		var chatRoom ChatRoom
		err := cursor.Decode(&chatRoom)
		if err != nil {
			return nil, fmt.Errorf("解码聊天室时出错: %v", err)
		}
		chatRooms = append(chatRooms, chatRoom)
	}

	if err := cursor.Err(); err != nil {
		return nil, fmt.Errorf("遍历查询结果时出错: %v", err)
	}

	return chatRooms, nil
}

// getUnreadMessages 根据聊天室ID和用户ID查询未读消息
func getUnreadMessages(monDB *mongo.Database, chatRoomID primitive.ObjectID, userID string) ([]ChatMessage, error) {
	ChatRoomCollection := monDB.Collection("ChatRoom")
	ChatMessageCollection := monDB.Collection("ChatMessage")
	// 查询聊天室信息
	var chatRoom ChatRoom
	err := ChatRoomCollection.FindOne(context.Background(), bson.M{"_id": chatRoomID}).Decode(&chatRoom)
	if err != nil {
		return nil, fmt.Errorf("查询聊天室信息时出错: %v", err)
	}

	//// 获取用户的未读消息数量
	//unreadMessagesCount, ok := chatRoom.UnreadMessages[userID]
	//if !ok {
	//	return nil, fmt.Errorf("用户 %s 在聊天室 %s 中不存在未读消息", userID, chatRoomID)
	//}

	// 构建查询条件
	filter := bson.M{
		"roomID": chatRoomID,
		"senderID": bson.M{
			"$ne": userID, // 发送者ID不等于当前用户ID
		},
		"read": false, // 未读状态
	}

	// 执行查询
	cursor, err := ChatMessageCollection.Find(context.Background(), filter)
	if err != nil {
		return nil, fmt.Errorf("查询未读消息时出错: %v", err)
	}
	defer cursor.Close(context.Background())

	// 解码查询结果
	var unreadMessages []ChatMessage
	for cursor.Next(context.Background()) {
		var message ChatMessage
		err := cursor.Decode(&message)
		if err != nil {
			return nil, fmt.Errorf("解码未读消息时出错: %v", err)
		}
		unreadMessages = append(unreadMessages, message)
	}

	if err := cursor.Err(); err != nil {
		return nil, fmt.Errorf("遍历查询结果时出错: %v", err)
	}

	// 更新用户的未读消息数量为0
	chatRoom.UnreadMessages[userID] = 0

	// 更新聊天室信息
	_, err = ChatRoomCollection.UpdateOne(context.Background(), bson.M{"_id": chatRoomID}, bson.M{"$set": bson.M{"unreadMessages": chatRoom.UnreadMessages}})
	if err != nil {
		return nil, fmt.Errorf("更新聊天室信息时出错: %v", err)
	}

	// 标记未读消息为已读
	for _, msg := range unreadMessages {
		// 更新查询条件
		updateFilter := bson.M{
			"_id": msg.ID,
		}

		// 更新操作
		update := bson.M{
			"$set": bson.M{"Read": true},
		}

		// 执行更新操作
		_, err := ChatMessageCollection.UpdateOne(context.Background(), updateFilter, update)
		if err != nil {
			return nil, fmt.Errorf("更新未读消息时出错: %v", err)
		}
	}

	return unreadMessages, nil
}

// getChatRoomHistory 获取聊天室历史记录
func getChatRoomHistory(collection *mongo.Collection, chatRoomID string, timestamp string) ([]ChatMessage, error) {
	// 将传入的时间戳解析为 time.Time 对象
	t, err := time.Parse(time.RFC3339, timestamp)
	if err != nil {
		return nil, fmt.Errorf("解析时间戳时出错: %v", err)
	}

	// 构建查询条件，选择指定时间之前的十条消息
	filter := bson.M{
		"roomID": chatRoomID,
		"timestamp": bson.M{
			"$lt": t,
		},
	}

	// 执行查询并按时间降序排序
	opts := options.Find().SetSort(bson.M{"timestamp": -1}).SetLimit(10)
	cursor, err := collection.Find(context.Background(), filter, opts)
	if err != nil {
		return nil, fmt.Errorf("查询历史消息时出错: %v", err)
	}
	defer cursor.Close(context.Background())

	// 解码查询结果
	var historyMessages []ChatMessage
	for cursor.Next(context.Background()) {
		var message ChatMessage
		err := cursor.Decode(&message)
		if err != nil {
			return nil, fmt.Errorf("解码历史消息时出错: %v", err)
		}
		historyMessages = append(historyMessages, message)
	}

	if err := cursor.Err(); err != nil {
		return nil, fmt.Errorf("遍历查询结果时出错: %v", err)
	}

	return historyMessages, nil
}

// SaveChatMessage 方法用于将聊天信息保存到 MongoDB 中
func SaveChatMessage(monDB *mongo.Database, chatRoomID primitive.ObjectID, senderID string, content string) error {
	ChatRoomCollection := monDB.Collection("ChatRoom")
	ChatMessageCollection := monDB.Collection("ChatMessage")
	// 查询聊天室信息
	var chatRoom ChatRoom
	err := ChatRoomCollection.FindOne(context.Background(), bson.M{"_id": chatRoomID}).Decode(&chatRoom)
	if err != nil {
		return fmt.Errorf("查询聊天室信息时出错: %v", err)
	}

	// 获取另一个用户的ID
	var otherUserID string
	for userID := range chatRoom.UnreadMessages {
		if userID != senderID {
			otherUserID = userID
			break
		}
	}

	// 增加另一个用户的未读消息数量
	chatRoom.UnreadMessages[otherUserID] = chatRoom.UnreadMessages[otherUserID] + 1

	// 更新聊天室信息
	_, err = ChatRoomCollection.UpdateOne(context.Background(), bson.M{"_id": chatRoomID}, bson.M{"$set": bson.M{"unreadMessages": chatRoom.UnreadMessages}})
	if err != nil {
		return fmt.Errorf("更新聊天室信息时出错: %v", err)
	}

	// 构建 ChatMessage 对象
	message := ChatMessage{
		RoomID:    chatRoomID,
		SenderID:  senderID,
		Content:   content,
		Read:      false,
		Timestamp: time.Now().Unix(),
	}

	// 执行插入操作
	_, err = ChatMessageCollection.InsertOne(context.Background(), message)
	if err != nil {
		return fmt.Errorf("保存聊天信息时出错: %v", err)
	}

	// 更新聊天室的最后一条消息和最后活跃时间
	update := bson.M{
		"$set": bson.M{
			"lastActiveTime": message.Timestamp,
			"lastMessage":    message.Content,
		},
	}
	filter := bson.M{"_id": chatRoomID}

	_, err = ChatRoomCollection.UpdateOne(context.Background(), filter, update)
	if err != nil {
		return fmt.Errorf("更新聊天室信息时出错: %v", err)
	}

	return nil
}
